package com.tanhua.server.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.tanhua.server.mapper.*;
import com.tanhua.server.pojo.*;
import com.tanhua.server.utils.UserThreadLocal;
import com.tanhua.server.vo.QuestionnaireVo;
import com.tanhua.server.vo.SoulQuestionOptionVo;
import com.tanhua.server.vo.SoulQuestionVo;
import com.tanhua.server.vo.SoulReportVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Li QiChao
 * @Description: 测灵魂 业务层
 * @Date: Created in 10:46 2021/1/17
 * @ModifiedBy:
 */
@Service
public class SoulService {

    @Autowired
    private QuestionUserLockMapper questionUserLockMapper;

    @Autowired
    private QuestionnaireMapper questionnaireMapper;

    @Autowired
    private SoulQuestionMapper soulQuestionMapper;

    @Autowired
    private SoulQuestionOptionMapper soulQuestionOptionMapper;

    @Autowired
    private QuestionnaireResultMapper questionnaireResultMapper;

    @Autowired
    private QuestionnaireReportMapper questionnaireReportMapper;

    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 查询问卷列表
     * @return
     */
    public List<QuestionnaireVo> queryQuestionnaireList() {
        // 获取user
        User user = UserThreadLocal.get();

        // user_id查mysql(用户对应问卷锁) == 几个锁 == 几套问卷
        QueryWrapper<QuestionUserLock> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("user_id", user.getId());
        List<QuestionUserLock> questionUserLock = this.questionUserLockMapper.selectList(queryWrapper1);

        // 遍历锁, 填充 问卷id + 锁状态 [几套试卷遍历几次]
        List<QuestionnaireVo> questionnaireVoList = new ArrayList<>();
        for (QuestionUserLock questionUserLocks : questionUserLock) {
            QuestionnaireVo questionnaireVo = new QuestionnaireVo();
            questionnaireVo.setId(questionUserLocks.getQuestionnaireId());
            questionnaireVo.setIsLock(questionUserLocks.getIsLock());
            questionnaireVoList.add(questionnaireVo);
        }

        // 遍历锁, 构建问卷Id列表
        List<String> questionnaireId = new ArrayList();
        for (QuestionUserLock UserId : questionUserLock) {
            questionnaireId.add(UserId.getQuestionnaireId());
        }

        // 问卷id查mysql(问卷) == 问卷对象列表
        QueryWrapper<Questionnaire> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.in("id", questionnaireId);
        List<Questionnaire> soulQuestionnaire = this.questionnaireMapper.selectList(queryWrapper2);

        // 双循环遍历 问卷pojo列表+问卷vo列表, 两者id相同时, 填充
        // 填充: 级别 名称 封面 星别
        for (Questionnaire questionnaire : soulQuestionnaire) {
            for (QuestionnaireVo questionnaireVo : questionnaireVoList) {
                if (questionnaire.getId().equals(questionnaireVo.getId().toString())) {
                    questionnaireVo.setLevel(questionnaire.getLevel());
                    questionnaireVo.setName(questionnaire.getName());
                    questionnaireVo.setCover(questionnaire.getCover());
                    questionnaireVo.setStar(questionnaire.getStar());
                }
            }
        }

        // 遍历问卷vo
        for (QuestionnaireVo questionnaireVo : questionnaireVoList) {

            // 问卷id查mysql(问题表) == 问题列表
            QueryWrapper<SoulQuestion> queryWrapper3 = new QueryWrapper<>();
            queryWrapper3.in("questionnaire_id", questionnaireVo.getId());
            List<SoulQuestion> soulQuestions = this.soulQuestionMapper.selectList(queryWrapper3);

            // 遍历问题vo
            List<SoulQuestionVo> soulQuestionVos = new ArrayList<>();
            for (SoulQuestion soulQuestion : soulQuestions) {

                // 填充: 问题id 题干
                SoulQuestionVo soulQuestionVo = new SoulQuestionVo();
                soulQuestionVo.setId(String.valueOf(soulQuestion.getId()));
                soulQuestionVo.setQuestion(soulQuestion.getStem());
                soulQuestionVo.setCreated(soulQuestion.getCreated());
                soulQuestionVo.setUpdated(soulQuestion.getUpdated());
                soulQuestionVos.add(soulQuestionVo);
                // question_id查mysql(选项表) == 选项列表
                QueryWrapper<SoulQuestionOption> queryWrapper4 = new QueryWrapper<>();
                queryWrapper4.in("question_id", soulQuestion.getId());
                List<SoulQuestionOption> soulQuestionList = this.soulQuestionOptionMapper.selectList(queryWrapper4);

                // 填充: 选项id 选项内容
                List<SoulQuestionOptionVo> soulQuestionOptionVo = new ArrayList<>();
                for (SoulQuestionOption option : soulQuestionList) {
                    SoulQuestionOptionVo soulQuestionOptionVo1 = new SoulQuestionOptionVo();
                    soulQuestionOptionVo1.setId(String.valueOf(option.getId()));
                    soulQuestionOptionVo1.setOption(option.getContent());
                    soulQuestionOptionVo1.setCreated(option.getCreated());
                    soulQuestionOptionVo1.setUpdated(option.getUpdated());
                    soulQuestionOptionVo.add(soulQuestionOptionVo1);
                }
                soulQuestionVo.setOptions(soulQuestionOptionVo);
            }
            questionnaireVo.setQuestions(soulQuestionVos);
        }
        return questionnaireVoList;
    }

    /**
     * 提交问卷，计算得分
     * @param answersList
     * @return
     */
    public Long commitQuestionnaire(List<Answers> answersList) {

        // 问卷得分
        Integer score = 0;
        // 问卷编号
        Long questionId = 0L;
        // 获取user
        User user = UserThreadLocal.get();

        // 遍历answers，计算每题总得分
        for (Answers answers : answersList) {
            questionId = answers.getQuestionId();
            Long optionId = answers.getOptionId();
            // 选项id查mysql（问题选项表） == 目的是得到每个选项的得分
            QueryWrapper queryWrapper = new QueryWrapper();
            queryWrapper.eq("id", optionId);
            SoulQuestionOption soulQuestionOption = soulQuestionOptionMapper.selectOne(queryWrapper);
            score += Integer.parseInt(soulQuestionOption.getScore());
        }

        // 题目id查mysql（问题表） == 目的是得到当前问卷id
        SoulQuestion soulQuestion = soulQuestionMapper.selectById(questionId);
        Long questionnaireId = soulQuestion.getQuestionnaireId();

        // 提交该等级问卷后，自动开启下一等级问卷（默认初级开启）
        QueryWrapper<QuestionUserLock> queryWrapper = new QueryWrapper();
        if (questionnaireId<=2){
            queryWrapper.eq("questionnaire_id", questionnaireId+1);
            QuestionUserLock questionUserLock = questionUserLockMapper.selectOne(queryWrapper);
            if(questionUserLock.getIsLock().equals(1)){
                questionUserLock.setIsLock(0);
                questionUserLockMapper.update(questionUserLock,queryWrapper);
            }
        }

        // 问卷id查mysql（问卷结果） == 该问卷有多少种结果【列表】
        QueryWrapper<QuestionnaireResult> queryResult = new QueryWrapper<>();
        queryResult.eq("questionnaire_id", questionnaireId);
        List<QuestionnaireResult> questionnaireResults = questionnaireResultMapper.selectList(queryResult);

        // 构建问卷报告对象，填充：用户id 问卷id
        QuestionnaireReport questionnaireReport = new QuestionnaireReport();
        questionnaireReport.setUserId(user.getId());
        questionnaireReport.setQuestionnaireId(questionnaireId);

        // 遍历问卷结果，确定 当前问卷得分 在哪个 问卷结果 的范围之内，填充结果id
        for (QuestionnaireResult questionnaireResult : questionnaireResults) {
            String[] split = questionnaireResult.getScope().split(",");
            if (score >= Integer.valueOf(split[0]) && score <= Integer.valueOf(split[1])) {
                questionnaireReport.setResultId(questionnaireResult.getId());
                break;
            }
        }

        // 问卷报告存mysql
        questionnaireReportMapper.insert(questionnaireReport);
        return questionnaireReport.getId();

    }

    /**
     * 查看问卷结果报告
     * @param id
     * @return SoulReportVo
     */
    public SoulReportVo getSoulReport(Long id) {
        // 构建返回值vo
        SoulReportVo soulReportVo = new SoulReportVo();

        // 报告id查mysql（问卷报告） == 目的是得到问卷结果对象id
        QuestionnaireReport questionnaireReport = questionnaireReportMapper.selectById(id);
        Long resultId = questionnaireReport.getResultId();

        // 问卷结果对象id查mysql（问卷结果对象）== 填充性格特点 == 维度key
        QuestionnaireResult questionnaireResult = questionnaireResultMapper.selectById(resultId);
        List<Dimensions> dimensionList = new ArrayList<>();
        dimensionList.add(new Dimensions("外向",questionnaireResult.getExtroversion()));
        dimensionList.add(new Dimensions("判断",questionnaireResult.getJudgement()));
        dimensionList.add(new Dimensions("抽象",questionnaireResult.getAbstraction()));
        dimensionList.add(new Dimensions("理性",questionnaireResult.getRationality()));

        // 填充：鉴定结果 鉴定图片 维度
        soulReportVo.setConclusion(questionnaireResult.getContent());
        soulReportVo.setCover(questionnaireResult.getCover());
        soulReportVo.setDimensions(dimensionList);

        // 与你相似
        // 问卷结果对象id查mysql（问卷结果对象）== 问卷结果相同的用户集合
        QueryWrapper<QuestionnaireReport> queryWrapper = new QueryWrapper();
        queryWrapper.eq("result_id",resultId);
        List<QuestionnaireReport> questionnaireReports = questionnaireReportMapper.selectList(queryWrapper);

        // 获取用户集合ids
        List<Long> userIds = new ArrayList<>();
        for (QuestionnaireReport report : questionnaireReports) {
            userIds.add(report.getUserId());
        }

        // 用户集合ids查mysql（用户信息表）
        QueryWrapper<UserInfo> queryWrapper1 = new QueryWrapper();
        queryWrapper1.in("user_id",userIds);
        List<UserInfo> userInfos = userInfoMapper.selectList(queryWrapper1);

        // 遍历用户信息列表，剔除当前用户自身，填充：与你相似
        ArrayList<SimilarYou> similarYouList = new ArrayList<>();
        for (UserInfo userInfo : userInfos) {
            if(UserThreadLocal.get().getId().equals(userInfo.getUserId())){
                continue;
            }
            similarYouList.add(new SimilarYou(userInfo.getUserId(),userInfo.getLogo()));
        }

        soulReportVo.setSimilarYou(similarYouList);
        return soulReportVo;
    }
}
